home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 286_01 / equiv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-23  |  4.9 KB  |  278 lines
  1. #include <stdio.h>
  2. #include <dos.h>
  3. #include <gds.h>
  4.  
  5. /*
  6. int far *calcaddr(x,y)
  7. int x,y;
  8. {
  9.   long tloc;
  10.   int temp;
  11.  
  12.   tloc = (y & 0x01) ? 0xba000000L : 0xb8000000L;
  13.   temp = y >> 1;
  14.   tloc += (temp << 4) + (temp << 6) + ((x >> 3) & 0xfffe);
  15.   return ( (int far *) tloc );
  16. }  
  17.  
  18. set_text()
  19. {
  20.   union REGS inregs;
  21.   union REGS outregs;
  22.  
  23.   inregs.h.al = 2;
  24.   inregs.h.ah = 0;
  25.   int86(0x10,&inregs,&outregs);
  26. }
  27.  
  28. set_graph()
  29. {
  30.   union REGS inregs;
  31.   union REGS outregs;
  32.  
  33.   inregs.h.al = 6;
  34.   inregs.h.ah = 0;
  35.   int86(0x10,&inregs,&outregs);
  36. }
  37. */
  38.  
  39. dot(x,y)
  40. int x,y;
  41. {
  42.   int far *addr;
  43.  
  44.   addr=calcaddr(x,y);
  45.   fr_write(addr,DOTVALUE[x & 0x0f]);
  46. }
  47.  
  48. vertline(x,y,length)
  49. int x,y,length;
  50. {
  51.   int far *addr, far *downline();
  52.   unsigned int pword;
  53.   int loop;
  54.  
  55.   addr=calcaddr(x,y);
  56.   LASTY=y;
  57.   pword=DOTVALUE[x & 0x0f];
  58.   while (length-- > 0) {
  59.     fr_write(addr,pword);
  60.     addr=downline(addr);
  61.     }
  62. }
  63.  
  64. horzline(x,y,length)
  65. int x,y,length;
  66. {
  67.   int far *addr;
  68.   unsigned int pword;
  69.   int len,loop;
  70.  
  71.   addr=calcaddr(x,y);
  72.   len = (x & 0x0f) + length;
  73.   if (len <= 16) {
  74.     pword=LEFTWORD[x & 0x0f] ^ LEFTWORD[len];
  75.     fr_write(addr,pword);
  76.     return;
  77.     }
  78.   fr_write(addr,LEFTWORD[x & 0x0f]);
  79.   addr++;
  80.   for (loop=len >> 4; loop > 1; loop--,addr++)
  81.     fr_write(addr,0xffff);
  82.   fr_write(addr,RIGHTWORD[len & 0x0f]);
  83. }
  84.  
  85. circle_pt(ctrx,ctry,x,y)
  86. int ctrx,ctry,x,y;
  87. {
  88.   dot(x+ctrx,y+ctry);
  89.   dot(y+ctrx,x+ctry);
  90.   dot(y+ctrx,-x+ctry);
  91.   dot(x+ctrx,-y+ctry);
  92.   dot(-x+ctrx,-y+ctry);
  93.   dot(-y+ctrx,-x+ctry);
  94.   dot(-y+ctrx,x+ctry);
  95.   dot(-x+ctrx,y+ctry);
  96. }
  97.  
  98. circle(centerx,centery,radius)
  99. int centerx,centery,radius;
  100. { 
  101.   int x,y,d, incr1, incr2;
  102.  
  103.   x=0;
  104.   y=radius;
  105.   incr1=6;
  106.   incr2=10-(radius<<2);
  107.   d=3-(radius<<1);
  108.   while (x < y) {
  109.     circle_pt(centerx,centery,x++,y);
  110.     if (d<0) {
  111.         d+=incr1;
  112.         incr2+=4;
  113.     } else {
  114.         d+=incr2;
  115.         incr2+=8;
  116.         y--;
  117.     }
  118.     incr1+=4;
  119.   }
  120.   if (x==y) circle_pt(centerx,centery,x,y);
  121. }
  122.  
  123. ellipse_pt(ctrx,ctry,x,y)
  124. int ctrx,ctry,x,y;
  125. {
  126.   dot(x+ctrx,y+ctry);
  127.   dot(x+ctrx,-y+ctry);
  128.   dot(-x+ctrx,-y+ctry);
  129.   dot(-x+ctrx,y+ctry);
  130. }
  131.  
  132. ellipse(ctrx,ctry,a,b)
  133. int ctrx,ctry,a,b;
  134. {
  135.   long incr1,incr2,a2,b2,d,step1,step2,ptx,pty;
  136.   int x,y;
  137.  
  138.   x=0;
  139.   y=b;
  140.   a2= (long) a * a;
  141.   b2= (long) b * b;
  142.   step1 = a2 << 2;
  143.   step2 = b2 << 2;
  144.   d= ((b2 - (a2 * b)) << 1) + a2;
  145.   incr1= step2 + (b2 << 1);
  146.   incr2= step1 + step2 + (b2 << 1) - ((a2 * b) << 2);
  147.   ptx=0;
  148.   pty=a2 * y;
  149.   while (ptx < pty) {
  150.     ellipse_pt(ctrx,ctry,x++,y);
  151.     if (d<0)
  152.       d+=incr1;
  153.     else {
  154.       d+=incr2;
  155.       incr2+=step1;
  156.       y--;
  157.       pty-=a2;
  158.       }
  159.     ptx+=b2;
  160.     incr1+=step2;
  161.     incr2+=step2;
  162.     }
  163.   if (ptx == pty) ellipse_pt(ctrx,ctry,x,y);
  164.   y=0;
  165.   x=a;
  166.   d= ((a2 - (b2 * a)) << 1) + b2;
  167.   incr1= step1 + (a2 << 1);
  168.   incr2= step2 + step1 + (a2 << 1) - ((b2 * a) << 2);
  169.   pty=0;
  170.   ptx=b2 * x;
  171.   while (pty < ptx) {
  172.     ellipse_pt(ctrx,ctry,x,y++);
  173.     if (d<0)
  174.       d+=incr1;
  175.     else {
  176.       d+=incr2;
  177.       incr2+=step2;
  178.       x--;
  179.       ptx-=b2;
  180.       }
  181.     pty+=a2;
  182.     incr1+=step1;
  183.     incr2+=step1;
  184.     }
  185.   if (ptx==pty) ellipse_pt(ctrx,ctry,x,y);
  186. }
  187.  
  188. line(x1,y1,x2,y2)
  189. int x1,y1,x2,y2;
  190. {
  191.   int dx,dy,d,x,y,xend,yend,len,incr1,incr2,xdir,ydir,dir;
  192.  
  193.   xdir=ydir=0;
  194.   if ((dx=x2-x1) < 0) { dx = -dx; xdir=(-1); }
  195.   if ((dy=y2-y1) < 0) { dy = -dy; ydir=(-1); }
  196.   if (dx == 0) {
  197.     if (xdir)
  198.       vertline(x1,y2,++dy);
  199.     else
  200.       vertline(x1,y1,++dy);
  201.     }
  202.   if (dy == 0) {
  203.     if (ydir)
  204.       horzline(x1,y2,++dx);
  205.     else
  206.       horzline(x1,y1,++dx);
  207.     }
  208.   if ((xdir==(-1)) && (ydir==(-1)))
  209.     dir=1;
  210.   else if (xdir || ydir)
  211.     dir=xdir+ydir;
  212.   else
  213.     dir=1;
  214.   if (dy <= dx) {
  215.     d = (dy << 1) - dx;
  216.     incr1 = dy << 1;
  217.     incr2 = (dy - dx) << 1;
  218.     if (xdir) {
  219.       x=x2; y=y2; xend=x1;
  220.       }
  221.     else {
  222.       x=x1; y=y1; xend=x2;
  223.       }
  224.     len=1;
  225.     while (x++<xend) {
  226.       if (d<0) {
  227.         d+=incr1;
  228.         len++;
  229.         }
  230.       else {
  231.         horzline(x-len,y,len);
  232.         len=1;
  233.         d+=incr2;
  234.         y+=dir;
  235.         }
  236.       }
  237.     horzline(x-len,y,len);
  238.     }
  239.   else {
  240.     d = (dx << 1) - dy;
  241.     incr1 = dx << 1;
  242.     incr2 = (dx - dy) << 1;
  243.     if (ydir) {
  244.       x=x2; y=y2; yend=y1;
  245.       }
  246.     else {
  247.       x=x1; y=y1; yend=y2;
  248.       }
  249.     len=1;
  250.     while (y++<yend) {
  251.       if (d<0) {
  252.         d+=incr1;
  253.         len++;
  254.         }
  255.       else {
  256.         vertline(x,y-len,len);
  257.         len=1;
  258.         d+=incr2;
  259.         x+=dir;
  260.         }
  261.       }
  262.     vertline(x,y-len,len);
  263.     }
  264. }
  265.  
  266. main()
  267. {
  268.     setgraph();
  269.     horzline(0,0,640);
  270.     vertline(0,0,200);
  271.     line(0,0,639,199);
  272.     circle(320,100,90);
  273.     ellipse(320,100,300,95);
  274.     getch();
  275.     settext();
  276. }
  277.  
  278.